/**
 * 大规模单元测试知识增强器
 * 
 * 基于对12931个真实OpenHarmony单元测试的深度学习：
 * - 覆盖所有子系统：base, commonlibrary, drivers, foundation
 * - 分析成功率：100%
 * 
 * 核心发现：
 * 1. ⭐ 90.98%的测试使用TEST_F（测试夹具）
 * 2. ⭐ 74.72%的测试使用SetUp/TearDown
 * 3. ⭐ 58.26%使用智能指针（比fuzzer低，更灵活）
 * 4. ⭐ 33.77%使用单例GetInstance
 * 5. ⭐ 14.32%使用Mock（重要测试技术）
 * 6. ⭐ 36.21%使用std::vector管理buffer
 */

export class MassiveUnitTestKnowledgeEnhancer {
    
    /**
     * 🎯 测试框架模式：TEST_F + SetUp/TearDown
     */
    public static getTestFrameworkGuidance(): string {
        return `
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
## 🎯 测试框架规范（基于12931个真实UT的统计）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

**统计结果：90.98%的测试使用TEST_F，74.72%使用SetUp/TearDown！**

### ✅ 模式1：TEST_F + 测试夹具（最主流，90.98%）

\`\`\`cpp
class YourServiceTest : public testing::Test {
protected:
    // ✅ 74.72%的测试都有SetUp和TearDown
    void SetUp() override {
        // 测试前初始化
        service_ = std::make_shared<YourService>();
        // 设置测试环境、权限、Mock等
    }
    
    void TearDown() override {
        // 测试后清理
        service_ = nullptr;
        // 清理测试环境、恢复状态等
    }
    
    // 测试成员变量
    std::shared_ptr<YourService> service_;
    std::shared_ptr<MockCallback> callback_;
};

// 使用TEST_F宏定义测试用例
TEST_F(YourServiceTest, TestMethod001) {
    // tc.name: 测试用例名称
    // tc.desc: 测试描述
    // tc.type: FUNC
    // tc.require: 需求ID
    
    EXPECT_NE(service_, nullptr);
    EXPECT_EQ(service_->Method(), EXPECTED_VALUE);
}

TEST_F(YourServiceTest, TestMethod002) {
    // 每个TEST_F都会调用SetUp和TearDown
    EXPECT_TRUE(service_->AnotherMethod());
}
\`\`\`

**为什么使用TEST_F？**
- ✅ 可以在多个测试用例间共享测试成员变量
- ✅ SetUp/TearDown自动管理测试环境
- ✅ 避免代码重复
- ✅ 更好的测试隔离

### ⚠️ 模式2：TEST宏（简单测试，8-9%）

\`\`\`cpp
// 用于不需要共享状态的简单测试
TEST(YourServiceTest, SimpleTest001) {
    YourService service;
    EXPECT_TRUE(service.Method());
}
\`\`\`

**何时使用TEST？**
- 简单的静态函数测试
- 不需要SetUp/TearDown
- 不需要共享测试状态

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
`;
    }
    
    /**
     * 🎯 对象创建模式
     */
    public static getObjectCreationGuidance(): string {
        return `
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
## 🎯 对象创建规范（基于12931个真实UT的统计）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

**统计结果：58.26%使用智能指针，33.77%使用单例！**

| 模式 | 数量 | 占比 | 推荐度 |
|------|------|------|--------|
| 智能指针 | 7534 | 58.26% | ⭐⭐⭐⭐⭐ 首选 |
| - make_shared | 4592 | 35.51% | 最常用 |
| - shared_ptr | 4665 | 36.07% | 常用 |
| - make_unique | 1173 | 9.07% | 独占 |
| - unique_ptr | 1024 | 7.92% | 独占 |
| - sptr | 2977 | 23.02% | IPC |
| 单例GetInstance | 4367 | 33.77% | ⭐⭐⭐⭐⭐ 常用 |
| DelayedSingleton | 403 | 3.12% | ⭐⭐⭐⭐ 系统服务 |
| 原始指针new | 2818 | 21.79% | ⚠️ 需手动delete |

### ✅ 推荐模式

\`\`\`cpp
class YourServiceTest : public testing::Test {
protected:
    void SetUp() override {
        // ✅ 方式1：智能指针（58.26%使用）
        service_ = std::make_shared<YourService>();
        callback_ = std::make_shared<MockCallback>();
        
        // ✅ 方式2：单例（33.77%使用）
        // 注意：GetInstance返回引用还是指针
        auto& singleton = YourSingleton::GetInstance();
        
        // ✅ 方式3：DelayedSingleton（3.12%，系统服务常用）
        DelayedSingleton<SystemService>::GetInstance()->Initialize();
    }
    
    std::shared_ptr<YourService> service_;
    std::shared_ptr<MockCallback> callback_;
};

TEST_F(YourServiceTest, TestMethod001) {
    // 使用箭头运算符调用
    service_->Method();
    
    // 单例使用点或箭头运算符（看返回类型）
    YourSingleton::GetInstance().Method();  // 返回引用
    DelayedSingleton<SystemService>::GetInstance()->Method();  // 返回指针
}
\`\`\`

### ⚠️ 原始指针模式（21.79%使用，需注意内存管理）

\`\`\`cpp
class YourServiceTest : public testing::Test {
protected:
    void SetUp() override {
        // ⚠️ 使用原始指针（需要手动管理内存）
        service_ = new YourService();
    }
    
    void TearDown() override {
        // ⚠️ 必须手动释放！
        if (service_ != nullptr) {
            delete service_;
            service_ = nullptr;
        }
    }
    
    YourService* service_ = nullptr;
};
\`\`\`

**注意**：虽然21.79%的测试使用原始指针，但**强烈推荐使用智能指针**以避免内存泄漏！

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
`;
    }
    
    /**
     * 🎭 Mock使用模式（重要！）
     */
    public static getMockGuidance(): string {
        return `
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
## 🎭 Mock测试规范（基于12931个真实UT，14.32%使用Mock）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

**统计数据：**
- Mock使用率：14.32%（1852个测试文件）
- Mock类定义：521个
- EXPECT_CALL：1852次
- WillOnce：1084次

### ✅ 完整的Mock模式

**1. 定义Mock类（通常在独立的mock头文件中）**

\`\`\`cpp
// mock_callback.h
#include <gmock/gmock.h>

class MockIDMCallback : public IIDMCallback {
public:
    MOCK_METHOD3(OnResult, void(int32_t result, const Attributes& extraInfo));
    MOCK_METHOD2(OnAcquireInfo, void(int32_t module, const Attributes& acquireInfo));
};

class MockSystemAbilityStatusChange : public SystemAbilityStatusChangeStub {
public:
    MOCK_METHOD2(OnAddSystemAbility, void(int32_t systemAbilityId, const std::string& deviceId));
    MOCK_METHOD2(OnRemoveSystemAbility, void(int32_t systemAbilityId, const std::string& deviceId));
};
\`\`\`

**2. 在测试中使用Mock**

\`\`\`cpp
#include "mock_callback.h"
using ::testing::_;
using ::testing::Return;
using ::testing::Exactly;

class AccountIAMClientTest : public testing::Test {
protected:
    void SetUp() override {
        // 创建Mock对象
        callback_ = std::make_shared<MockIDMCallback>();
        EXPECT_NE(callback_, nullptr);
        
        // 创建测试回调包装（如果需要）
        testCallback_ = std::make_shared<TestIDMCallback>(callback_);
    }
    
    std::shared_ptr<MockIDMCallback> callback_;
    std::shared_ptr<TestIDMCallback> testCallback_;
};

TEST_F(AccountIAMClientTest, OpenSession001) {
    // 设置期望：期望OnResult被调用1次，参数为ERR_OK
    EXPECT_CALL(*callback_, OnResult(ERR_OK, _))
        .Times(Exactly(1));
    
    // 设置期望：期望OnAcquireInfo被调用，使用WillOnce返回
    EXPECT_CALL(*callback_, OnAcquireInfo(_, _))
        .WillOnce(Return());
    
    // 执行测试
    AccountIAMClient::GetInstance().OpenSession(testCallback_);
    
    // 等待异步回调（如果需要）
    std::unique_lock<std::mutex> lock(testCallback_->mutex_);
    testCallback_->cv_.wait_for(lock, std::chrono::seconds(3));
}
\`\`\`

**3. Mock参数匹配**

\`\`\`cpp
using ::testing::Eq;
using ::testing::Ne;
using ::testing::Gt;
using ::testing::Lt;
using ::testing::_;

// 精确匹配
EXPECT_CALL(*mock, Method(Eq(10), Eq("test")));

// 任意值
EXPECT_CALL(*mock, Method(_, _));

// 条件匹配
EXPECT_CALL(*mock, Method(Gt(0), Ne("")));
\`\`\`

**4. Mock返回值**

\`\`\`cpp
using ::testing::Return;
using ::testing::ReturnRef;

// 返回值
EXPECT_CALL(*mock, GetValue())
    .WillOnce(Return(42))
    .WillOnce(Return(100));

// 返回引用
static std::string testStr = "test";
EXPECT_CALL(*mock, GetString())
    .WillOnce(ReturnRef(testStr));
\`\`\`

**5. Mock调用次数**

\`\`\`cpp
using ::testing::Exactly;
using ::testing::AtLeast;
using ::testing::AtMost;

// 精确次数
EXPECT_CALL(*mock, Method()).Times(Exactly(1));

// 至少N次
EXPECT_CALL(*mock, Method()).Times(AtLeast(1));

// 至多N次
EXPECT_CALL(*mock, Method()).Times(AtMost(3));

// 重复调用
EXPECT_CALL(*mock, Method()).WillRepeatedly(Return(0));
\`\`\`

### 📁 Mock文件组织

\`\`\`
test/unittest/
├── src/
│   └── your_service_test.cpp         # 测试实现
└── include/
    └── mock_callback.h                # Mock类定义
\`\`\`

### 🔍 真实示例（来自account_iam_client_test.cpp）

\`\`\`cpp
auto callback = std::make_shared<MockIDMCallback>();
EXPECT_NE(callback, nullptr);

#ifdef PROXY_MOCK
EXPECT_CALL(*callback, OnResult(ERR_ACCOUNT_ZIDL_ACCOUNT_SERVICE_ERROR, _))
    .Times(Exactly(1));
#else
EXPECT_CALL(*callback, OnResult(_, _))
    .Times(Exactly(1));
#endif

auto testCallback = std::make_shared<TestIDMCallback>(callback);
EXPECT_NE(testCallback, nullptr);

AccountIAMClient::GetInstance().OpenSession(testCallback);
\`\`\`

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
`;
    }
    
    /**
     * 🔌 NDK/NAPI/CJSON测试模式
     */
    public static getSpecialInterfaceGuidance(): string {
        return `
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
## 🔌 特殊接口测试模式
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

### 1. NDK接口测试（6.22%的测试，7268种接口）

**统计数据：**
- NDK测试占比：6.22%
- 接口种类：7268种
- 主要类别：HiLog, HiAppEvent, HiSysEvent, HiTrace, InputMethod

\`\`\`cpp
#include <hilog/log.h>

TEST_F(HiLogTest, TestLog001) {
    // 使用NDK日志接口
    OH_LOG_INFO(LOG_CORE, "Test log message: %{public}d", 42);
    OH_LOG_DEBUG(LOG_CORE, "Debug message");
    OH_LOG_ERROR(LOG_CORE, "Error message");
    
    // 检查日志级别
    bool loggable = OH_LOG_IsLoggable(LOG_DOMAIN, "TAG", LOG_INFO);
    EXPECT_TRUE(loggable);
}

TEST_F(NativeWindowTest, TestWindow001) {
    // NativeWindow测试
    auto window = OH_NativeWindow_CreateNativeWindow(&surfaceNode);
    EXPECT_NE(window, nullptr);
    
    // 使用window
    int32_t ret = OH_NativeWindow_NativeWindowSetScalingMode(window, mode);
    EXPECT_EQ(ret, OHOS_SURFACE_ERROR_OK);
    
    // 释放资源
    OH_NativeWindow_DestroyNativeWindow(window);
}
\`\`\`

### 2. NAPI接口测试（1.48%的测试，374种接口）

\`\`\`cpp
#include <napi/native_api.h>

class NapiTest : public testing::Test {
protected:
    void SetUp() override {
        env_ = (napi_env)engine_;
    }
    
    napi_env env_;
};

TEST_F(NapiTest, TestUndefinedType001) {
    napi_value result = nullptr;
    
    // 获取undefined值
    napi_status status = napi_get_undefined(env_, &result);
    EXPECT_EQ(status, napi_ok);
    EXPECT_NE(result, nullptr);
    
    // 检查类型
    napi_valuetype valueType = napi_undefined;
    EXPECT_EQ(napi_typeof(env_, result, &valueType), napi_ok);
    EXPECT_EQ(valueType, napi_undefined);
}

TEST_F(NapiTest, TestCreateFunction001) {
    napi_value func = nullptr;
    
    // 创建函数
    napi_status status = napi_create_function(
        env_, "testFunc", NAPI_AUTO_LENGTH,
        [](napi_env env, napi_callback_info info) -> napi_value {
            return nullptr;
        },
        nullptr, &func
    );
    
    EXPECT_EQ(status, napi_ok);
    EXPECT_NE(func, nullptr);
}
\`\`\`

### 3. CJSON测试模式（0.58%的测试）

\`\`\`cpp
#include <cjson/cJSON.h>

TEST_F(JsonUtilsTest, CreateJsonNullTest001) {
    // 创建JSON null值
    auto jsonObj = CreateJsonNull();
    EXPECT_TRUE(cJSON_IsNull(jsonObj.get()));
}

TEST_F(JsonUtilsTest, ParseJsonTest001) {
    std::string jsonStr = R"({"name": "test", "age": 18})";
    
    // 解析JSON
    cJSON* jsonObj = cJSON_Parse(jsonStr.c_str());
    ASSERT_NE(jsonObj, nullptr);
    
    // 获取字段
    cJSON* nameItem = cJSON_GetObjectItem(jsonObj, "name");
    EXPECT_NE(nameItem, nullptr);
    EXPECT_STREQ(nameItem->valuestring, "test");
    
    // 释放
    cJSON_Delete(jsonObj);
}

TEST_F(JsonUtilsTest, CreateJsonTest001) {
    // 创建JSON对象
    cJSON* jsonObj = cJSON_CreateObject();
    ASSERT_NE(jsonObj, nullptr);
    
    // 添加字段
    cJSON_AddStringToObject(jsonObj, "name", "test");
    cJSON_AddNumberToObject(jsonObj, "age", 18);
    
    // 转为字符串
    char* jsonStr = cJSON_Print(jsonObj);
    EXPECT_NE(jsonStr, nullptr);
    
    // 释放
    cJSON_Delete(jsonObj);
    free(jsonStr);
}
\`\`\`

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
`;
    }
    
    /**
     * 🔐 权限/文件/Buffer/线程模式
     */
    public static getCommonPatternsGuidance(): string {
        return `
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
## 🔐 常用测试模式
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

### 1. 权限校验测试（3.62%的测试）

\`\`\`cpp
#include "accesstoken_kit.h"

class PermissionTest : public testing::Test {
protected:
    void SetUp() override {
        // 获取当前token
        tokenId_ = GetSelfTokenID();
        
        // 设置测试权限
        SetAccessTokenPermission("ohos.permission.TEST_PERMISSION", tokenId_);
    }
    
    void TearDown() override {
        // 清理权限
        RemoveAccessTokenPermission("ohos.permission.TEST_PERMISSION", tokenId_);
    }
    
    uint64_t tokenId_;
};

TEST_F(PermissionTest, VerifyPermission001) {
    // 验证权限
    int ret = AccessTokenKit::VerifyAccessToken(
        tokenId_, "ohos.permission.TEST_PERMISSION"
    );
    EXPECT_EQ(ret, PERMISSION_GRANTED);
}
\`\`\`

### 2. 文件操作测试

\`\`\`cpp
class FileOperationTest : public testing::Test {
protected:
    void SetUp() override {
        testFilePath_ = "/data/test/test_file.txt";
    }
    
    void TearDown() override {
        // 清理测试文件
        if (std::filesystem::exists(testFilePath_)) {
            std::filesystem::remove(testFilePath_);
        }
    }
    
    std::string testFilePath_;
};

TEST_F(FileOperationTest, WriteAndReadFile001) {
    // ✅ 推荐：使用C++ stream（ifstream: 136, ofstream: 175）
    std::ofstream ofs(testFilePath_);
    ASSERT_TRUE(ofs.is_open());
    
    ofs << "test content";
    ofs.close();
    
    std::ifstream ifs(testFilePath_);
    ASSERT_TRUE(ifs.is_open());
    
    std::string content;
    std::getline(ifs, content);
    EXPECT_EQ(content, "test content");
    ifs.close();
}

TEST_F(FileOperationTest, CStyleFileOperation001) {
    // ⚠️ C风格文件操作（fopen: 146）
    FILE* fp = fopen(testFilePath_.c_str(), "w");
    ASSERT_NE(fp, nullptr);
    
    fwrite("test", 1, 4, fp);
    fclose(fp);
}
\`\`\`

### 3. Buffer管理测试（std::vector是首选！）

\`\`\`cpp
TEST_F(BufferTest, VectorBuffer001) {
    // ✅ 强烈推荐：std::vector（36.21%的测试使用）
    size_t size = 1024;
    std::vector<uint8_t> buffer(size);
    
    // 自动管理内存，RAII
    // 使用buffer
    EXPECT_EQ(buffer.size(), size);
    EXPECT_NE(buffer.data(), nullptr);
    
    // 无需手动释放
}

TEST_F(BufferTest, MallocBuffer001) {
    // ⚠️ 如必须使用malloc（malloc: 230, free: 351）
    size_t size = 1024;
    uint8_t* buffer = (uint8_t*)malloc(size);
    ASSERT_NE(buffer, nullptr);
    
    // 使用buffer
    memset(buffer, 0, size);
    
    // ⚠️ 必须手动释放！
    free(buffer);
}
\`\`\`

### 4. 线程相关测试（2.40%的测试）

\`\`\`cpp
class ThreadTest : public testing::Test {
protected:
    std::mutex mutex_;
    std::condition_variable cv_;
    bool ready_ = false;
};

TEST_F(ThreadTest, ThreadCommunication001) {
    // 创建工作线程
    std::thread worker([this]() {
        // 模拟工作
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        
        // 通知主线程
        {
            std::lock_guard<std::mutex> lock(mutex_);
            ready_ = true;
        }
        cv_.notify_one();
    });
    
    // 等待通知
    {
        std::unique_lock<std::mutex> lock(mutex_);
        cv_.wait(lock, [this]() { return ready_; });
    }
    
    EXPECT_TRUE(ready_);
    
    // 等待线程结束
    worker.join();
}

TEST_F(ThreadTest, MutexTest001) {
    // 互斥锁保护（mutex: 300）
    std::lock_guard<std::mutex> lock(mutex_);
    // 临界区代码
}
\`\`\`

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
`;
    }
    
    /**
     * 📦 头文件依赖和断言
     */
    public static getHeadersAndAssertionsGuidance(): string {
        return `
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
## 📦 头文件依赖和断言使用
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

### 1. 标准头文件顺序

\`\`\`cpp
// 1. 版权声明
/*
 * Copyright (c) 2025 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 */

// 2. 测试框架头文件
#include <gtest/gtest.h>
#include <gmock/gmock.h>

// 3. 系统头文件
#include <memory>
#include <string>
#include <vector>

// 4. OpenHarmony系统头文件
#include <hilog/log.h>
#include <napi/native_api.h>

// 5. 项目头文件
#include "your_service.h"

// 6. Mock头文件
#include "mock_callback.h"
\`\`\`

### 2. 常用测试断言

**EXPECT vs ASSERT的区别：**
- EXPECT：失败后继续执行
- ASSERT：失败后立即返回

\`\`\`cpp
TEST_F(YourTest, TestAssertions001) {
    // ✅ 相等断言（最常用，71.73%的测试使用EXPECT_EQ）
    EXPECT_EQ(actual, expected);
    ASSERT_EQ(actual, expected);  // 失败立即返回
    
    // ✅ 不等断言
    EXPECT_NE(ptr, nullptr);
    
    // ✅ 布尔断言
    EXPECT_TRUE(condition);
    EXPECT_FALSE(condition);
    
    // ✅ 比较断言
    EXPECT_GT(value, 0);  // greater than
    EXPECT_LT(value, 100);  // less than
    EXPECT_GE(value, 0);  // greater or equal
    EXPECT_LE(value, 100);  // less or equal
    
    // ✅ 字符串断言
    EXPECT_STREQ(str1, str2);
    EXPECT_STRNE(str1, str2);
    
    // ✅ 浮点数断言
    EXPECT_FLOAT_EQ(f1, f2);
    EXPECT_DOUBLE_EQ(d1, d2);
    
    // ✅ 异常断言
    EXPECT_THROW(function(), std::exception);
    EXPECT_NO_THROW(function());
}
\`\`\`

### 3. GTest常用功能

\`\`\`cpp
// 测试夹具
class YourTest : public testing::Test {
protected:
    // 每个TEST_F前执行
    void SetUp() override {}
    
    // 每个TEST_F后执行
    void TearDown() override {}
    
    // 整个测试套件前执行一次
    static void SetUpTestSuite() {}
    
    // 整个测试套件后执行一次
    static void TearDownTestSuite() {}
};

// 参数化测试
class ParameterizedTest : public testing::TestWithParam<int> {};

TEST_P(ParameterizedTest, TestWithParameter) {
    int param = GetParam();
    EXPECT_GT(param, 0);
}

INSTANTIATE_TEST_SUITE_P(
    TestSuite,
    ParameterizedTest,
    testing::Values(1, 2, 3, 4, 5)
);
\`\`\`

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
`;
    }
    
    /**
     * 构建完整的增强Prompt
     */
    public static enhancePrompt(basePrompt: string): string {
        return `${basePrompt}

${this.getTestFrameworkGuidance()}

${this.getObjectCreationGuidance()}

${this.getMockGuidance()}

${this.getSpecialInterfaceGuidance()}

${this.getCommonPatternsGuidance()}

${this.getHeadersAndAssertionsGuidance()}

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
## 🎯 最终要求（基于12931个真实UT的硬性规范）
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

1. ✅ **测试框架**：必须使用TEST_F + SetUp/TearDown（**90.98%**遵循）
2. ✅ **对象创建**：优先使用智能指针（**58.26%**使用），单例也常用（**33.77%**）
3. ✅ **Mock使用**：对于接口测试，使用GMock（**14.32%**的测试使用）
4. ✅ **Buffer管理**：优先使用std::vector（**36.21%**使用）
5. ✅ **断言**：多使用EXPECT_EQ等断言（**71.73%**使用）
6. ✅ **NDK测试**：使用OH_前缀的NDK接口（**6.22%**的测试）
7. ✅ **NAPI测试**：正确使用napi_env和napi_value（**1.48%**的测试）
8. ✅ **权限测试**：使用AccessTokenKit设置和验证权限（**3.62%**的测试）
9. ✅ **线程测试**：使用std::thread和std::mutex（**2.40%**的测试）
10. ✅ **代码注释**：包含tc.name, tc.desc, tc.type, tc.require等注释

**这些不是建议，而是基于12931个真实UT的经验总结！**

**统计数据来源**：全面分析OHCode下12931个单元测试文件的真实数据

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
`;
    }
}

